home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 June / PCWorld_2007-06_cd.bin / v cisle / tclock / tclocklight-040702-3.exe / source / dll / formattime.c < prev    next >
Encoding:
C/C++ Source or Header  |  2004-07-02  |  11.9 KB  |  516 lines
  1. /*-------------------------------------------------------------
  2.   formattime.c : handle format picture strings of time
  3.   (C) 1997-2003 Kazuto Sato
  4.   Please read readme.txt about the license.
  5.   
  6.   Written by Kazubon, Nanashi-san
  7. ---------------------------------------------------------------*/
  8.  
  9. #include "tcdll.h"
  10.  
  11. /* Globals */
  12.  
  13. void InitFormatTime(void);
  14. void SDateHandler(FORMATHANDLERSTRUCT* pstruc);
  15. void STimeHandler(FORMATHANDLERSTRUCT* pstruc);
  16. void YearHandler(FORMATHANDLERSTRUCT* pstruc);
  17. void MonthHandler(FORMATHANDLERSTRUCT* pstruc);
  18. void DateHandler(FORMATHANDLERSTRUCT* pstruc);
  19. void DayOfWeekHandler(FORMATHANDLERSTRUCT* pstruc);
  20. void HourHandler(FORMATHANDLERSTRUCT* pstruc);
  21. void MinuteHandler(FORMATHANDLERSTRUCT* pstruc);
  22. void SecondHandler(FORMATHANDLERSTRUCT* pstruc);
  23. void AMPMHandler(FORMATHANDLERSTRUCT* pstruc);
  24. void CRLFHandler(FORMATHANDLERSTRUCT* pstruc);
  25. void CharaHandler(FORMATHANDLERSTRUCT* pstruc);
  26. void AltYearHandler(FORMATHANDLERSTRUCT* pstruc);
  27. void EraHandler(FORMATHANDLERSTRUCT* pstruc);
  28. void TimeDifHandler(FORMATHANDLERSTRUCT* pstruc);
  29. void LDATEHandler(FORMATHANDLERSTRUCT* pstruc);
  30. void DATEHandler(FORMATHANDLERSTRUCT* pstruc);
  31. void TIMEHandler(FORMATHANDLERSTRUCT* pstruc);
  32. void MSecondHandler(FORMATHANDLERSTRUCT* pstruc);
  33.  
  34. /* Statics */
  35.  
  36. static BOOL m_bHour12, m_bHourZero;
  37. static wchar_t m_DayOfWeekShort[7][11], m_DayOfWeekLong[7][31];
  38. static wchar_t m_MonthShort[12][11], m_MonthLong[12][31];
  39. static wchar_t *m_DayOfWeekEng[7] =
  40.   { L"Sun", L"Mon", L"Tue", L"Wed", L"Thu", L"Fri", L"Sat" };
  41. static wchar_t *m_MonthEng[12] =
  42.   { L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun",
  43.     L"Jul", L"Aug", L"Sep", L"Oct", L"Nov", L"Dec" };
  44. static wchar_t m_AM[11], m_PM[11], m_SDate[5], m_STime[5];
  45. static wchar_t m_EraStr[11];
  46. static int m_AltYear;
  47.  
  48. /*------------------------------------------------
  49.   initialize string of day, month
  50. --------------------------------------------------*/
  51. void InitFormatTime(void)
  52. {
  53.     SYSTEMTIME t;
  54.     wchar_t s[80];
  55.     int i, ilang, ioptcal, codepage;
  56.     int ilangcal, codepagecal;
  57.     
  58.     g_bDispSecond = FALSE;
  59.     
  60.     GetLocalTime(&t);
  61.     
  62.     m_bHour12 = GetMyRegLong(NULL, "Hour12", 0);
  63.     m_bHourZero = GetMyRegLong(NULL, "HourZero", 0);
  64.     
  65.     ilang = GetMyRegLong(NULL, "Locale", (int)GetUserDefaultLangID());
  66.     
  67.     codepage = GetCodePage(ilang);
  68.     
  69.     for(i = 0; i < 7; i++)
  70.     {
  71.         int j;
  72.         if(i == 0) j = 6; else j = i - 1;
  73.         MyGetLocaleInfoW(ilang, codepage, LOCALE_SABBREVDAYNAME1 + j,
  74.             m_DayOfWeekShort[i], 10);
  75.         MyGetLocaleInfoW(ilang, codepage, LOCALE_SDAYNAME1 + j,
  76.             m_DayOfWeekLong[i], 30);
  77.     }
  78.     for(i = 0; i < 12; i++)
  79.     {
  80.         MyGetLocaleInfoW(ilang, codepage, LOCALE_SABBREVMONTHNAME1 + i,
  81.             m_MonthShort[i], 10);
  82.         MyGetLocaleInfoW(ilang, codepage, LOCALE_SMONTHNAME1 + i,
  83.             m_MonthLong[i], 30);
  84.     }
  85.     
  86.     GetMyRegStrW(NULL, "AMsymbol", s, 80, "");
  87.     if(s[0]) wcscpy(m_AM, s);
  88.     else
  89.     {
  90.         MyGetLocaleInfoW(ilang, codepage, LOCALE_S1159, m_AM, 10);
  91.         if(m_AM[0] == 0) wcscpy(m_AM, L"AM");
  92.     }
  93.     GetMyRegStrW(NULL, "PMsymbol", s, 80, "");
  94.     if(s[0]) wcscpy(m_PM, s);
  95.     else
  96.     {
  97.         MyGetLocaleInfoW(ilang, codepage, LOCALE_S2359, m_PM, 10);
  98.         if(m_PM[0] == 0) wcscpy(m_PM, L"PM");
  99.     }
  100.     
  101.     MyGetLocaleInfoW(ilang, codepage, LOCALE_SDATE, m_SDate, 4);
  102.     MyGetLocaleInfoW(ilang, codepage, LOCALE_STIME, m_STime, 4);
  103.     
  104.     m_EraStr[0] = 0;
  105.     m_AltYear = 0;
  106.     
  107.     ioptcal = 0;
  108.     ilangcal = ilang;
  109.     codepagecal = codepage;
  110.     if(MyGetLocaleInfoW(ilang, codepage, LOCALE_IOPTIONALCALENDAR,
  111.         s, 10) > 0)
  112.     {
  113.         ioptcal = _wtoi(s);
  114.     }
  115.     if(ioptcal == 0)
  116.     {
  117.         ilangcal = GetUserDefaultLangID();
  118.         codepagecal = GetCodePage(ilangcal);
  119.         if(MyGetLocaleInfoW(ilangcal, codepagecal,
  120.             LOCALE_IOPTIONALCALENDAR, s, 10) > 0)
  121.         {
  122.             ioptcal = _wtoi(s);
  123.         }
  124.     }
  125.     
  126.     if(ioptcal > 0)
  127.     {
  128.         if(MyGetDateFormatW(ilangcal, codepagecal,
  129.             DATE_USE_ALT_CALENDAR, &t, L"gg", s, 12) > 0)
  130.             wcscpy(m_EraStr, s);
  131.         
  132.         if(MyGetDateFormatW(ilangcal, codepagecal,
  133.             DATE_USE_ALT_CALENDAR, &t, L"yyyy", s, 6) > 0)
  134.             m_AltYear = _wtoi(s);
  135.     }
  136. }
  137.  
  138. /*------------------------------------------------
  139.   format handlers
  140. --------------------------------------------------*/
  141.  
  142. /* / */
  143. void SDateHandler(FORMATHANDLERSTRUCT* pstruc)
  144. {
  145.     const wchar_t *p = m_SDate;
  146.     while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  147.     pstruc->sp++;
  148. }
  149.  
  150. /* : */
  151. void STimeHandler(FORMATHANDLERSTRUCT* pstruc)
  152. {
  153.     const wchar_t *p = m_STime;
  154.     while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  155.     pstruc->sp++;
  156. }
  157.  
  158. /* y, yy, yyy, yyyy */
  159. void YearHandler(FORMATHANDLERSTRUCT* pstruc)
  160. {
  161.     int keta = 0;
  162.     int year = (int)pstruc->pt->wYear;
  163.     
  164.     while(*pstruc->sp == 'y')
  165.     {
  166.         pstruc->sp++;
  167.         keta++;
  168.         if(keta == 4) break;
  169.     }
  170.     
  171.     if(keta == 4)
  172.     {
  173.         if(*pstruc->dp)
  174.             *pstruc->dp++ = (wchar_t)(year / 1000 + '0');
  175.     }
  176.     if(keta >= 3)
  177.     {
  178.         if(*pstruc->dp)
  179.             *pstruc->dp++ = (wchar_t)((year % 1000) / 100 + '0');
  180.     }
  181.     if(keta >= 2)
  182.     {
  183.         if(*pstruc->dp)
  184.             *pstruc->dp++ = (wchar_t)((year % 100) / 10 + '0');
  185.     }
  186.     if(*pstruc->dp)
  187.         *pstruc->dp++ = (wchar_t)(year % 10 + '0');
  188. }
  189.  
  190. /* m, mm, mmm, mmmm, mme */
  191. void MonthHandler(FORMATHANDLERSTRUCT* pstruc)
  192. {
  193.     int keta = 0;
  194.     
  195.     while(*pstruc->sp == 'm')
  196.     {
  197.         pstruc->sp++;
  198.         keta++;
  199.         if(keta == 4) break;
  200.     }
  201.     
  202.     if(keta == 2 && *pstruc->sp == 'e')
  203.     {
  204.         const wchar_t* p;
  205.         pstruc->sp++;
  206.         p = m_MonthEng[pstruc->pt->wMonth-1];
  207.         while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  208.     }
  209.     else
  210.     {
  211.         if(keta >= 3)
  212.         {
  213.             const wchar_t* p;
  214.             if(keta == 4) p = m_MonthLong[pstruc->pt->wMonth-1];
  215.             else p = m_MonthShort[pstruc->pt->wMonth-1];
  216.             while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  217.         }
  218.         else
  219.         {
  220.             int mon = (int)pstruc->pt->wMonth;
  221.             if(keta == 2 || mon > 9)
  222.             {
  223.                 if(*pstruc->dp)
  224.                     *pstruc->dp++ = (wchar_t)(mon / 10 + '0');
  225.             }
  226.             if(*pstruc->dp)
  227.                 *pstruc->dp++ = (wchar_t)(mon % 10 + '0');
  228.         }
  229.     }
  230. }
  231.  
  232. /* d, dd, ddd, dddd, dde */
  233. void DateHandler(FORMATHANDLERSTRUCT* pstruc)
  234. {
  235.     int keta = 0;
  236.     
  237.     while(*pstruc->sp == 'd')
  238.     {
  239.         pstruc->sp++;
  240.         keta++;
  241.         if(keta == 4) break;
  242.     }
  243.     
  244.     if(keta == 2 && *pstruc->sp == 'e')
  245.     {
  246.         const wchar_t* p;
  247.         pstruc->sp++;
  248.         p = m_DayOfWeekEng[pstruc->pt->wDayOfWeek];
  249.         while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  250.     }
  251.     else
  252.     {
  253.         if(keta >= 3) {
  254.             const wchar_t* p;
  255.             if(keta == 4) p = m_DayOfWeekLong[pstruc->pt->wDayOfWeek];
  256.             else p = m_DayOfWeekShort[pstruc->pt->wDayOfWeek];
  257.             while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  258.         }
  259.         else
  260.         {
  261.             int day = (int)pstruc->pt->wDay;
  262.             if(keta == 2 || day > 9)
  263.             {
  264.                 if(*pstruc->dp)
  265.                     *pstruc->dp++ = (wchar_t)(day / 10 + '0');
  266.             }
  267.             if(*pstruc->dp)
  268.                 *pstruc->dp++ = (wchar_t)(day % 10 + '0');
  269.         }
  270.     }
  271. }
  272.  
  273. /* aaa, aaaa */
  274. void DayOfWeekHandler(FORMATHANDLERSTRUCT* pstruc)
  275. {
  276.     const wchar_t* p;
  277.     
  278.     pstruc->sp += 3;
  279.     if(*pstruc->sp == 'a')
  280.     {
  281.         pstruc->sp++;
  282.         p = m_DayOfWeekLong[pstruc->pt->wDayOfWeek];
  283.     }
  284.     else p = m_DayOfWeekShort[pstruc->pt->wDayOfWeek];
  285.     
  286.     while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  287. }
  288.  
  289. /* h, hh */
  290. void HourHandler(FORMATHANDLERSTRUCT* pstruc)
  291. {
  292.     int keta = 1;
  293.     int hour = (int)pstruc->pt->wHour;
  294.     
  295.     if(m_bHour12)
  296.     {
  297.         if(hour > 12) hour -= 12;
  298.         else if(hour == 0) hour = 12;
  299.         if(hour == 12 && m_bHourZero) hour = 0;
  300.     }
  301.     
  302.     pstruc->sp++;
  303.     if(*pstruc->sp == 'h') { keta++; pstruc->sp++; }
  304.     if(keta == 2 || hour > 9)
  305.     {
  306.         if(*pstruc->dp)
  307.             *pstruc->dp++ = (wchar_t)(hour / 10 + '0');
  308.     }
  309.     if(*pstruc->dp)
  310.         *pstruc->dp++ = (wchar_t)(hour % 10 + '0');
  311. }
  312.  
  313. /* n, nn */
  314. void MinuteHandler(FORMATHANDLERSTRUCT* pstruc)
  315. {
  316.     int min = (int)pstruc->pt->wMinute;
  317.     int keta = 1;
  318.     pstruc->sp++;
  319.     if(*pstruc->sp == 'n') { keta++; pstruc->sp++; }
  320.     if(keta == 2 || min > 9)
  321.     {
  322.         if(*pstruc->dp)
  323.             *pstruc->dp++ = (wchar_t)(min / 10 + '0');
  324.     }
  325.     if(*pstruc->dp)
  326.         *pstruc->dp++ = (wchar_t)(min % 10 + '0');
  327. }
  328.  
  329. /* s, ss */
  330. void SecondHandler(FORMATHANDLERSTRUCT* pstruc)
  331. {
  332.     int sec = (int)pstruc->pt->wSecond;
  333.     int keta = 1;
  334.     pstruc->sp++;
  335.     if(*pstruc->sp == 's') { keta++; pstruc->sp++; }
  336.     if(keta == 2 || sec > 9)
  337.     {
  338.         if(*pstruc->dp)
  339.             *pstruc->dp++ = (wchar_t)(sec / 10 + '0');
  340.     }
  341.     if(*pstruc->dp)
  342.         *pstruc->dp++ = (wchar_t)(sec % 10 + '0');
  343.     
  344.     g_bDispSecond = TRUE;
  345. }
  346.  
  347. /* tt */
  348. void AMPMHandler(FORMATHANDLERSTRUCT* pstruc)
  349. {
  350.     const wchar_t* p;
  351.     
  352.     pstruc->sp += 2;
  353.     if(pstruc->pt->wHour < 12) p = m_AM; else p = m_PM;
  354.     while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  355. }
  356.  
  357. /* \n */
  358. void CRLFHandler(FORMATHANDLERSTRUCT* pstruc)
  359. {
  360.     pstruc->sp += 2;
  361.     if(*pstruc->dp && *(pstruc->dp + 1))
  362.     {
  363.         *pstruc->dp++ = 0x0d; *pstruc->dp++ = 0x0a;
  364.     }
  365. }
  366.  
  367. /* \x1234; */
  368. void CharaHandler(FORMATHANDLERSTRUCT* pstruc)
  369. {
  370.     wchar_t ch = 0;
  371.     
  372.     pstruc->sp += 2;
  373.     while(*pstruc->sp)
  374.     {
  375.         if('0' <= *pstruc->sp && *pstruc->sp <= '9')
  376.             ch = (wchar_t)(ch * 16 + *pstruc->sp - '0');
  377.         else if('A' <= *pstruc->sp && *pstruc->sp <= 'F')
  378.             ch = (wchar_t)(ch * 16 + *pstruc->sp - 'A' + 10);
  379.         else if('a' <= *pstruc->sp && *pstruc->sp <= 'f')
  380.             ch = (wchar_t)(ch * 16 + *pstruc->sp - 'a' + 10);
  381.         else
  382.         {
  383.             if(*pstruc->sp == ';') pstruc->sp++;
  384.             break;
  385.         }
  386.         pstruc->sp++;
  387.     }
  388.     
  389.     if(ch == 0) ch = ' ';
  390.     if(*pstruc->dp) *pstruc->dp++ = ch;
  391. }
  392.  
  393. /* Y */
  394. void AltYearHandler(FORMATHANDLERSTRUCT* pstruc)
  395. {
  396.     int n = 1;
  397.     while(*pstruc->sp == 'Y') { n *= 10; pstruc->sp++; }
  398.     if(m_AltYear < 0) return;
  399.     if(n < m_AltYear)
  400.     {
  401.         n = 1; while(n < m_AltYear) n *= 10;
  402.     }
  403.     while(1)
  404.     {
  405.         if(*pstruc->dp)
  406.             *pstruc->dp++ = (wchar_t)((m_AltYear % n) / (n / 10) + '0');
  407.         if(n == 10) break;
  408.         n /= 10;
  409.     }
  410. }
  411.  
  412. /* g */
  413. void EraHandler(FORMATHANDLERSTRUCT* pstruc)
  414. {
  415.     const wchar_t *p;
  416.     p = m_EraStr;
  417.     while(*p && *pstruc->sp  == 'g' && *pstruc->dp)
  418.     {
  419.         *pstruc->dp++ = *p++;
  420.         pstruc->sp++;
  421.     }
  422.     while(*pstruc->sp == 'g') pstruc->sp++;
  423. }
  424.  
  425. /* w[+/-]nn : time difference */
  426. void TimeDifHandler(FORMATHANDLERSTRUCT* pstruc)
  427. {
  428.     int dif;
  429.     BOOL bMinus;
  430.     FILETIME ft;
  431.     
  432.     pstruc->sp += 2;
  433.     if(*pstruc->sp == '-') bMinus = TRUE;
  434.     else if(*pstruc->sp == '+') bMinus = FALSE;
  435.     else return;
  436.     pstruc->sp++;
  437.     
  438.     if('0' <= *pstruc->sp && *pstruc->sp <= '9')
  439.         dif = *pstruc->sp++ - '0';
  440.     else return;
  441.     if('0' <= *pstruc->sp && *pstruc->sp <= '9')
  442.         dif = dif * 10 + *pstruc->sp++ - '0';
  443.     dif *= 60;
  444.     if(*pstruc->sp == ':')
  445.     {
  446.         int dif2;
  447.         pstruc->sp++;
  448.         if('0' <= *pstruc->sp && *pstruc->sp <= '9')
  449.         {
  450.             dif2 = *pstruc->sp++ - '0';
  451.             if('0' <= *pstruc->sp && *pstruc->sp <= '9')
  452.                 dif2 = dif2 * 10 + *pstruc->sp++ - '0';
  453.         }
  454.         dif += dif2;
  455.     }
  456.     
  457.     SystemTimeToFileTime(pstruc->pt, &ft);
  458.     if(bMinus) *(DWORDLONG*)&ft -= M32x32to64(dif * 60, 10000000);
  459.     else       *(DWORDLONG*)&ft += M32x32to64(dif * 60, 10000000);
  460.     FileTimeToSystemTime(&ft, pstruc->pt);
  461. }
  462.  
  463. /* LDATE */
  464. void LDATEHandler(FORMATHANDLERSTRUCT* pstruc)
  465. {
  466.     wchar_t s[80];
  467.     const wchar_t* p;
  468.     MyGetDateFormatW(GetUserDefaultLangID(),
  469.         GetCodePage(GetUserDefaultLangID()),
  470.         DATE_LONGDATE, pstruc->pt, NULL, s, 80);
  471.     p = s;
  472.     while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  473.     pstruc->sp += 5;
  474. }
  475.  
  476. /* DATE */
  477. void DATEHandler(FORMATHANDLERSTRUCT* pstruc)
  478. {
  479.     wchar_t s[80];
  480.     const wchar_t* p;
  481.     MyGetDateFormatW(GetUserDefaultLangID(),
  482.         GetCodePage(GetUserDefaultLangID()),
  483.         DATE_SHORTDATE, pstruc->pt, NULL, s, 80);
  484.     p = s;
  485.     while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  486.     pstruc->sp += 4;
  487. }
  488.  
  489. /* TIME */
  490. void TIMEHandler(FORMATHANDLERSTRUCT* pstruc)
  491. {
  492.     wchar_t s[80];
  493.     const wchar_t* p;
  494.     MyGetTimeFormatW(GetUserDefaultLangID(),
  495.         GetCodePage(GetUserDefaultLangID()),
  496.         TIME_FORCE24HOURFORMAT, pstruc->pt, NULL, s, 80);
  497.     p = s;
  498.     while(*p && *pstruc->dp) *pstruc->dp++ = *p++;
  499.     pstruc->sp += 4;
  500. }
  501.  
  502. /* SSS  only for testing */
  503. void MSecondHandler(FORMATHANDLERSTRUCT* pstruc)
  504. {
  505.     int msec = (int)pstruc->pt->wMilliseconds;
  506.     
  507.     pstruc->sp += 3;
  508.     if(*pstruc->dp)
  509.         *pstruc->dp++ = (wchar_t)((msec % 1000) / 100 + '0');
  510.     if(*pstruc->dp)
  511.         *pstruc->dp++ = (wchar_t)((msec % 100) / 10 + '0');
  512.     if(*pstruc->dp)
  513.         *pstruc->dp++ = (wchar_t)(msec % 10 + '0');
  514. }
  515.  
  516.